

/***
 * 这个脚本文件是websocket的文件，控制着整个脚本的运行
 */



let {SERVER_BASE_ADDR, SERVER_BASE_ADDR_WS, EnumSysConf, UpDataUi, SetState, GetState, OpenScreen, ScreenLight, ScreenDim, ScreenClose,} = require('./Script_Base/Script_Base.js');
const { BringUpAcc, StopAllScipt, IntoSuperRoomByCare, StopBringUpAcc, StopIntoSuperRoomByCare } = require('./Script_Dy/Script_Dy_Main.js');


/**
 * 接收网络信息的枚举
 */
let EnumServerCmd = {
    LOAD_NEW_APP: 1,                    // 下载最新的脚本
    SCREEN_LIGHT: 2,                    // 点亮屏幕
    SCREEN_DIM: 3,                      // 让屏幕变暗
    SCREEN_CLOSE: 4,                    // 关闭屏幕
    // 更新相关
    UPLOAD_NEW_SCRIPT: 10,              // 更新最新的脚本文件
    UPLOAD_NEW_APP: 11,                 // 下载最新的App并安装设置
    UPLOAD_NEW_APP_DONE: 12,            // 完成下载任务

    UNINSTALL_OLD_APP: 19,              // 卸载老版本的App
    // 连接相关
    CONNECT_WEBSOCKET_SUCCESS: 101,     // WebSocket连接成功
    // 系统相关
    SYS_SET_USERINFO: 300,              // 设置用户信息
    SYS_SET_CONFIG: 301,                // 设置配置文件
    SYS_INIT_SET_PHONE: 305,            // 初始化设置手机
    // 抖音的相关信息
    DY_SCRIPT_RUNNING: 400,             // 运行抖音脚本
    DY_SCRIPT_STOP: 401,                // 停止抖音脚本
    DY_SCRIPT_SET_CONFIG: 404,          // 设置抖音脚本配置文件
    DY_SCRIPT_SCROLLVIDEO: 410,         // 运行自动刷抖音脚本
    DY_SCRIPT_STOP_SCROLLVIDEO: 411,    // 停止自动刷抖音脚本
    DY_SCRIPT_INTO_SUPER_ROOM: 420,     // 进入指定的直播间
    DY_SCRIPT_OUT_SUPER_ROOM: 421,      // 退出直播间并关闭抖音
    DY_SCRIPT_SCROLLLIVEROOM: 430,      // 运行自动刷抖音直播脚本
    DY_SCRIPT_STOP_SCROLLLIVEROOM: 431, // 停止自动刷抖音直播脚本

    DY_NEW_SCRIPT_BRINGUP_ACC: 4001,    // 运行自动养号脚本
    DY_NEW_SCRIPT_INTO_SUPER_ROOM_BY_CARE: 4002,    // 运行通过关注页进入直播间
    DY_NEW_SCRIPT_STOP_ALL_SCRIPT: 4100,        // 停止全部脚本
    DY_NEW_SCRIPT_STOP_BRINGUP_ACC: 4101,   // 停止运行自动养号脚本
    DY_NEW_SCRIPT_STOP_INTO_SUPER_ROOM_BY_CARE: 4102,    // 停止运行通过关注页进入直播间

    
    STOP_ALL_SCRIPT:5,                  // 停止全部的脚本

    // 错误相关
    ERROR_NO_USER: 600,                 // 没有此用户
    ERROR_NO_PWCARD: 601,               // 没有卡号

    // 设置手机相关内容
    SET_PHONE_NEWPHONE: 700,            // 设置新手机

    INFO_NORMAL: 900,                   // 正常的消息
    INFO_LOGIN: 901,                    // 手机登录
    INFO_HAVEGETCMD: 902,               // 已经获取了最新的命令

    properties: {
        1: {name: "small", value: 1, code: "S"},
        2: {name: "medium", value: 2, code: "M"},
        3: {name: "large", value: 3, code: "L"}
    }
};

/**
 * 自己的变量
 */
let EnumSlfConf = {
    SERVER_ADDR: "180.76.225.84/api",           // 服务器地址，这里还没有开始使用
    SERVER_LOAD_ADDR: "180.76.225.84/apps",     // 服务器地址，这里还没有开始使用
    b_isCloseWb: false,                         // true 关闭Websocket
    b_isCloseSlf: false,                        // true 关闭自己
    b_isUploadScriptFile: false,                // true 正在更新脚本文件
    b_isNeedLogin: true,                        // true 需要登录服务器
    b_isConnServer: false,                      // true 连接到了服务器
    mClient: new OkHttpClient(),
    request: new Request.Builder().get().url(SERVER_BASE_ADDR_WS).build(),
    globalWebsocket: null,
    b_isNewPhone: false,                        // true 是新的手机
    t_last_send_msg: new Date(),                // 最后发送消息的时间
}

function SetUiInfo(username, password_card) {

    if (username == "") {
        username = "vip001";
    }

    let storage = storages.create("rabbit:info");
    storage.put('username', username);
    storage.put('pw_card', password_card);

    UpDataUi();
}


/**
 * 获取服务器的命令
 */
function GetServerComand() {
    UpDataUi();
    threads.start(function(){
        SetState("开始运行脚本");
        // if (EnumSlfConf.b_isNewPhone) {
        //     saveDate();
        //     initSetPhone();
        //     sleep(1000 * 3);
        // }
        let success = true;
        while (!EnumSlfConf.b_isCloseWb) {
            try{
                if((EnumSlfConf.globalWebsocket==null && EnumSlfConf.b_isCloseWb == false) || !success){
                    SetState("准备连接服务器");

                    EnumSlfConf.b_isConnServer = false;
                    EnumSlfConf.b_isNeedLogin = true;
                    initWebSocket();
                    for (let index = 0; index < 20; index++) {
                        sleep(1000 * 1);
                        if (EnumSlfConf.b_isConnServer) {
                            console.log("接收到连接成功了");
                            break;
                        }
                    }
                    continue;
                }
                
                if (EnumSlfConf.b_isNeedLogin) {
                    SetState("登录服务器");
                    success = EnumSlfConf.globalWebsocket.send(JSON.stringify({
                        'cmd': EnumServerCmd.INFO_LOGIN,
                        'info': {
                            'username': EnumSysConf.username,
                            'pw_card': EnumSysConf.pw_card,
                            'imei': EnumSysConf.imei,
                        }
                    }));
                    EnumSlfConf.b_isNeedLogin = false;
                } else {
                    // console.log(new Date().Format('hh:mm:ss -> ') + '发送心跳包');
                    success = EnumSlfConf.globalWebsocket.send(JSON.stringify({
                        'cmd': EnumServerCmd.INFO_NORMAL,
                        'info': {
                            'username': EnumSysConf.username,
                            "pw_card": EnumSysConf.pw_card,
                            "imei": EnumSysConf.imei,
                            "runningScript": GetState(),
                        }
                    }));
                }

                if(success){
                    // 每13秒钟给服务器发送一次心跳包，发送自己当前状态，如果出现与服务器断开情况，时间不足可能产生websocket连接数量过多
                    EnumSlfConf.t_last_send_msg = new Date();
                    var d_sleep_time = random(10000, 13000);
                    // console.log(d_sleep_time);
                    do {
                        sleep(1000);
                        // console.log('休息1秒');
                        // console.log(new Date(new Date() - EnumSlfConf.t_last_send_msg).getTime());
                    } while (new Date(new Date() - EnumSlfConf.t_last_send_msg).getTime() < d_sleep_time && !EnumSlfConf.b_isCloseWb);
                }

            }catch(e){
                console.log(new Date().Format('hh:mm:ss -> ') + e);
            }
        }
    });
}

/**
 * 通过okhttp方式使用WebSockt
 * @param {*} fileName 
 * onOpen()，连接成功
 * onMessage(String text)，收到字符串类型的消息，一般我们都是使用这个
 * onMessage(ByteString bytes)，收到字节数组类型消息，我这里没有用到
 * onClosed()，连接关闭
 * onFailure()，连接失败，一般都是在这里发起重连操作
 */
function initWebSocket() {
    if (EnumSlfConf.b_isCloseWb == false) {
        EnumSlfConf.mClient.newWebSocket(EnumSlfConf.request, new JavaAdapter(WebSocketListener, {
            onOpen: function (webSocket, response) {
                EnumSlfConf.globalWebsocket=webSocket;
            },
            onMessage: function (webSocket, text) {
                console.log(text.toString());
                dispenseMessage(text);
                // console.log(EnumSlfConf.globalWebsocket);
            },
            onClosed: function (webSocket, code,reason) {
                console.error("onClosed 连接关闭");
                sleep(1000 * 5);
            },   
            onFailure: function (webSocket, throwable,response) {
                EnumSlfConf.b_isNeedLogin = true;
                webSocket.cancel();
                console.error(new Date().Format('hh:mm:ss -> ') + '连接失败');
                toast("服务器连接失败");
                // webSocket.close();
            }
        }));   
    }
}

/**
 * 处理收到的消息
 * TODO:这里应该改成线程方式，这里需要修改*******************
 * @param {*} msg 接收到的消息
 */
function dispenseMessage(msg){
    var info_conmand = JSON.parse(msg);
    /**
     * true，接收到有用的命令
     */
    var b_isGetUsefulCmd = true;
    function setGetCmdBool(b) {
        b_isGetUsefulCmd = b;
    }
    
    console.log(new Date().Format('hh:mm:ss -> ') + info_conmand["cmd"]);

    // return;

    switch (info_conmand["cmd"]) {
        case EnumServerCmd.LOAD_NEW_SCRIPT:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + "下载最新的脚本");
                //libEx.setState('下载最新的脚本');
            });
            break;
        case EnumServerCmd.SCREEN_LIGHT:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + "点亮屏幕");
                // OpenScreen();
                ScreenLight();
            });
            break;                

        case EnumServerCmd.SCREEN_DIM:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + "屏幕灰屏");
                ScreenDim();
            });
            break;  
        case EnumServerCmd.SCREEN_CLOSE:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + "关闭屏幕");
                ScreenClose();
            });
            break;        
        case EnumServerCmd.UPLOAD_NEW_SCRIPT:
            threads.start(function(){
                EnumSlfConf.b_isUploadScriptFile = true;
                console.log(new Date().Format('hh:mm:ss -> ') + "更新脚本文件");
                //libEx.setState('更新脚本文件');
                return;

                let sf = info_conmand["script"]
                // console.log(sf);
                // console.log(typeof(sf));
                let fn = sf["newScriptFileName"];
                let script_v = sf["version"];
                let slf_script_v = 0; //libEx.getScriptVersion();
                if (slf_script_v.Revision != script_v['Revision'] || slf_script_v.Minor != script_v['Minor'] || slf_script_v.Major != script_v['Major']) {
                    for (let index = 0; index < fn.length; index++) {
                        console.log(fn[index]);
                        EnumSlfConf.b_isUploadScriptFile == true;
                        LoadScritpFileEx(fn[index]);
                        let int_c = 0;
                        do {
                            int_c = int_c + 1;
                            sleep(10);
                        } while (EnumSlfConf.b_isUploadScriptFile == true && int_c < 500);
                    }
                    sleep(1000);
                    console.log(new Date().Format('hh:mm:ss -> ') + "可以重启脚本了");
                
                    // upgrade();
                    RestartMain();
                } else {
                    console.log('不需要更新脚本');
                }
            });
            break;
            
        case EnumServerCmd.UPLOAD_NEW_APP:
            threads.start(function(){
                // 服务器发送过来需要下载最新的App了。并发送过来下载的地址
                console.log(new Date().Format('hh:mm:ss -> ') + "通过浏览器下载最新的App");
                //libEx.setState('通过浏览器下载最新的App');

                // // console.log(info_conmand["app_name"]);
                // libEx.inistallAllByBrowser(info_conmand["url"],info_conmand["app_name"], info_conmand["app_package"] );

                // console.log("下载完成了。。。。。。。。");
                // closeSlf();
            });
            break;  
        
        case EnumServerCmd.CONNECT_WEBSOCKET_SUCCESS:
            setGetCmdBool(false);
            threads.start(function(){
                EnumSlfConf.b_isConnServer = true;
                //libEx.setState('连接成功');
                console.log(new Date().Format('hh:mm:ss -> ') + "连接成功");
            });
            break;
        case EnumServerCmd.SYS_SET_USERINFO:
            threads.start(function(){
                //libEx.setState('设置用户信息');
                console.log(new Date().Format('hh:mm:ss -> ') + "设置用户信息");

                EnumSysConf.pw_card = info_conmand["userinfo"]['pw_card']
                SetUiInfo("", EnumSysConf.pw_card);
            });
            break;
        case EnumServerCmd.SYS_SET_CONFIG:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + "设置配置信息");
                console.log(info_conmand["config"]);

                let storage = storages.create("rabbit:info");
                storage.put('t_in_tj_min', Number(info_conmand["config"]["t_in_tj_min"])*1000*60);
                storage.put('t_in_tj_max', Number(info_conmand["config"]["t_in_tj_max"])*1000*60);
                storage.put('t_in_gz_min', Number(info_conmand["config"]["t_in_gz_min"])*1000*60);
                storage.put('t_in_gz_max', Number(info_conmand["config"]["t_in_gz_max"])*1000*60);
                storage.put('t_in_zb_min', Number(info_conmand["config"]["t_in_zb_min"])*1000*60);
                storage.put('t_in_zb_max', Number(info_conmand["config"]["t_in_zb_max"])*1000*60);
                storage.put('int_in_grzy_min', Number(info_conmand["config"]["int_in_grzy_min"]));
                storage.put('int_in_grzy_max', Number(info_conmand["config"]["int_in_grzy_max"]));
                storage.put('super_man_name', info_conmand["config"]["super_man_name"]);
                storage.put('super_man_name_into_room', info_conmand["config"]["super_man_name_into_room"]);
                storage.put('t_in_care_room_min', Number(info_conmand["config"]["t_in_care_room_min"])*1000*60);
                storage.put('t_in_care_room_max', Number(info_conmand["config"]["t_in_care_room_max"])*1000*60);

                UpDataUi();
            });                       
            break;
        
        case EnumServerCmd.SYS_INIT_SET_PHONE:
            threads.start(function(){
                //libEx.setState('初始设置手机');
                console.log(new Date().Format('hh:mm:ss -> ') + "初始设置手机");
                return;
                initSetPhone();

                // // 1、关闭全部的App
                // libEx.closeAllRunningApps();

                // // 2、开启自己的设备管理器
                // libEx.activateAppDeviceAdmin('小猛虎');

                // // 3、卸载小虎App
                // libEx.uninstallApp('com.tiger.autoRun');

                // // 4、设置无锁屏
                // libEx.setNoLockScreen();
            });
            break;
        case EnumServerCmd.DY_SCRIPT_RUNNING:
            threads.start(function(){
                //libEx.setState('运行抖音脚本');
                console.log(new Date().Format('hh:mm:ss -> ') + "运行抖音脚本");
            });
            break;

        case EnumServerCmd.DY_SCRIPT_STOP:
            threads.start(function(){
                //libEx.setState('停止抖音脚本');
                console.log(new Date().Format('hh:mm:ss -> ') + "停止抖音脚本");
                return;
                script.Dy_StopAutoScrollVideo();
            });
            break;
        // case EnumServerCmd.DY_SCRIPT_INTO_LIVING:
        //     console.log("进入指定直播间");
        //     break;

        // case EnumServerCmd.DY_SCRIPT_INTO_LIVING_DELAY:
        //     console.log("进入指定直播间，带随机延迟");

        //     break;

        case EnumServerCmd.DY_SCRIPT_SET_CONFIG:
            threads.start(function(){
                //libEx.setState('设置抖音脚本配置文件');
                console.log(new Date().Format('hh:mm:ss -> ') + "设置抖音脚本配置文件");
            });
            break;

        case EnumServerCmd.DY_SCRIPT_SCROLLVIDEO:
            threads.start(function(){
                //libEx.setState('运行自动刷抖音脚本');
                console.log(new Date().Format('hh:mm:ss -> ') + '运行自动刷抖音脚本');
                return;
                script.Dy_ScrollVideo();
            });
            break;
        case EnumServerCmd.DY_SCRIPT_STOP_SCROLLVIDEO:
            threads.start(function(){
                //libEx.setState('停止自动刷抖音脚本');
                console.log(new Date().Format('hh:mm:ss -> ') + '停止自动刷抖音脚本');
                return;
                script.Dy_StopAutoScrollVideo();
            });
            break;

        case EnumServerCmd.DY_SCRIPT_INTO_SUPER_ROOM:
            threads.start(function(){
                //libEx.setState('进入指定的直播间');
                console.log(new Date().Format('hh:mm:ss -> ') + '进入指定的直播间');
                return;
                script.Dy_IntoSuperRoom();
            });
            break;
        case EnumServerCmd.DY_SCRIPT_OUT_SUPER_ROOM:
            threads.start(function(){
                //libEx.setState('退出直播间');
                console.log(new Date().Format('hh:mm:ss -> ') + '退出直播间');
                return;
                script.Dy_OutSuperRoomAndCloseDy();
            });
            break;

        case EnumServerCmd.DY_SCRIPT_SCROLLLIVEROOM:
            threads.start(function(){
                //libEx.setState('运行自动刷抖音直播间脚本');
                console.log(new Date().Format('hh:mm:ss -> ') + '运行自动刷抖音直播间脚本');
                return;
                script.Dy_ScrollLiveRoom();
            });
            break;
        case EnumServerCmd.DY_SCRIPT_STOP_SCROLLLIVEROOM:
            threads.start(function(){
                //libEx.setState('停止自动刷抖音直播间脚本');
                console.log(new Date().Format('hh:mm:ss -> ') + '停止自动刷抖音直播间脚本');
                return;
                script.Dy_StopAutoScrollLiveRoom();
            });
            break;
        case EnumServerCmd.DY_NEW_SCRIPT_BRINGUP_ACC:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + '运行自动养号脚本');
                BringUpAcc();
            });
            break;
        case EnumServerCmd.DY_NEW_SCRIPT_INTO_SUPER_ROOM_BY_CARE:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + '运行通过关注页进入直播间');
                IntoSuperRoomByCare();
            });
            break;
        case EnumServerCmd.DY_NEW_SCRIPT_STOP_BRINGUP_ACC:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + '停止运行自动养号脚本');
                StopBringUpAcc();
            });
            break;
        case EnumServerCmd.DY_NEW_SCRIPT_STOP_INTO_SUPER_ROOM_BY_CARE:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + '停止运行通过关注页进入直播间');
                StopIntoSuperRoomByCare();
            });
            break;
        case EnumServerCmd.STOP_ALL_SCRIPT:
            threads.start(function(){
                console.log(new Date().Format('hh:mm:ss -> ') + "停止全部脚本");
                StopAllScipt();
            });
            break;
        case EnumServerCmd.SET_PHONE_NEWPHONE:
            threads.start(function(){
                //libEx.setState('初始化设置手机');
                console.log(new Date().Format('hh:mm:ss -> ') + "初始化设置手机");

            });
            break;
        case EnumServerCmd.INFO_NORMAL:
            threads.start(function(){});
            // console.log("正常的消息");
            setGetCmdBool(false);
            break;
        default:
            setGetCmdBool(false);
            break;
    }  
    
    if (b_isGetUsefulCmd) {
        EnumSlfConf.t_last_send_msg = new Date();
        // console.log('命令在可选的范围内，回复服务器我接收到了消息');
        let success = EnumSlfConf.globalWebsocket.send(JSON.stringify({
            'cmd': EnumServerCmd.INFO_HAVEGETCMD,
            'info': {
                'username': EnumSysConf.username,
                "pw_card": EnumSysConf.pw_card,
                "imei": EnumSysConf.imei,
            }
        }));
        if(!success){
            EnumSlfConf.b_isNeedLogin = true;
            // initWebSocket();
            // sleep(1000 * 13);
            return;
        }
    }else{
        // console.log('不用回复服务器');
        return;
    }
}

/**
 * 设置是否需要连接的状态
 * @param {bool} state true：需要连接，false：不需要连接
 */
function SetCloseWb(state) {
    EnumSlfConf.b_isCloseWb = state;

    if (!state && EnumSlfConf.globalWebsocket != null) {
        EnumSlfConf.globalWebsocket.cancel();
    }
}

module.exports = {
    GetServerComand: GetServerComand,               // 获取服务器的命令

    SetCloseWb: SetCloseWb,                         // 设置是否需要连接的状态




}

